{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Working with jobs\n", "\n", "The job class obtained after running a QuantumCircuit has interesting properties that can be used." ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
     ┌───┐     \n",
       "q_0: ┤ H ├──■──\n",
       "     └───┘┌─┴─┐\n",
       "q_1: ─────┤ X ├\n",
       "          └───┘
" ], "text/plain": [ " ┌───┐ \n", "q_0: ┤ H ├──■──\n", " └───┘┌─┴─┐\n", "q_1: ─────┤ X ├\n", " └───┘" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import os\n", "from c12_callisto_clients.user_configs import UserConfigs\n", "from c12_callisto_clients.qiskit_back.c12sim_provider import C12SimProvider\n", "from qiskit import QuantumCircuit\n", "TOKEN = os.getenv(\"C12_TOKEN\")\n", "configs = UserConfigs.parse_obj({\"token\" : TOKEN})\n", "\n", "c12_simulator_provider = C12SimProvider(configs)\n", "c12_simulator_backend = c12_simulator_provider.get_backend('c12sim-iswap')\n", "\n", "\n", "circuit = QuantumCircuit(2)\n", "circuit.h(0)\n", "circuit.cx(0, 1)\n", "\n", "circuit.draw()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Two main methods available for each Job instance are job_id() and status().\n", "\n", "1. `job_id()` method returns the unique identifier of a job as a UUID4 string (a universally unique identifier (UUID), version 4, is a 36-character alphanumeric random generated string). This id can be used for later assessment of the job properties.\n", "\n", "2. `status()` method is used to get the status of a job execution as an instance of JobStatus class. Available statuses are:\n", " - `QUEUED` = Job is queued. It waits for execution\n", " - `RUNNING` = Job is currently running.\n", " - `CANCELLED` = Job has been canceled.\n", " - `DONE` = Job has been successfully done.\n", " - `ERROR` = There has been an error during the execution of a job.\n", "\n", "The status of a running job can be changed depending on the current state of job execution.\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Job id: 023e408a-bb92-4f48-a5c5-2336bcc8b21e\n", "Status: JobStatus.RUNNING\n" ] } ], "source": [ "c12_job = c12_simulator_backend.run(circuit)\n", "print(f\"Job id: {c12_job.job_id()}\") # Get a job UUID\n", "print(f\"Status: {c12_job.status()}\") # Get a current job status" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The result of a job execution can be obtained with the `result()` method. This method can have one optional argument (timeout). The `timeout` argument specifies how long the method will wait for the execution of the task. If the time limit is exceeded, the `C12SimJobError` exception is raised. If we do not specify this argument, its default value is None, meaning the method will block until the simulation is finished.\n", "\n", "Another way to get the results is to check the job status periodically until it is `DONE` and then call the `result()` function." ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "023e408a-bb92-4f48-a5c5-2336bcc8b21e: JobStatus.RUNNING\n", "023e408a-bb92-4f48-a5c5-2336bcc8b21e: JobStatus.DONE\n", "{'00': 487, '01': 1, '10': 2, '11': 534}\n" ] } ], "source": [ "from qiskit.providers import JobStatus\n", "import time\n", "job_final_states = [JobStatus.DONE, JobStatus.ERROR, JobStatus.CANCELLED]\n", "c12_job_id = c12_job.job_id()\n", "while True:\n", " job_status = c12_job.status()\n", " print(f'{c12_job_id}: {job_status}')\n", " if job_status in job_final_states:\n", " break\n", " time.sleep(5) # Wait 5 s\n", "\n", "if c12_job.status() == JobStatus.DONE:\n", " c12_result = c12_job.result()\n", " print(c12_result.get_counts())" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'00': 517, '01': 2, '10': 1, '11': 504}\n" ] } ], "source": [ "# Running a job that will block until finished\n", "c12_job = c12_simulator_backend.run(circuit)\n", "c12_result = c12_job.result()\n", "if c12_job.status() == JobStatus.DONE:\n", " print(c12_result.get_counts())" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [], "source": [ "# Getting a job result with a timeout argument specified\n", "from c12simulator_clients.qiskit_back.exceptions import C12SimJobError\n", "c12_job = c12_simulator_backend.run(circuit)\n", "\n", "try:\n", " c12_result = c12_job.result(timeout=15) # it will raise a C12SimJobError as it won't be finished in 15s\n", "except C12SimJobError:\n", " print(\"Timeout!\")\n", " print(f\" Last status: {c12_job.status()}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Getting previous jobs\n", "\n", "Next, an extremely useful functionality is the possibility to obtain all jobs run on the system by a specific user. Using this functionality, the user can get the results of old jobs.\n", "\n", "This can be achieved by calling the `jobs()` function on the backend instance. This function accepts two arguments: `limit` and `offset`. We can specify how many jobs we want to get with a `limit` argument. Likewise, we can set the `offset` from the first job with an offset argument. With these arguments, pagination is easily achieved." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1: a7fadc44-22f7-42a1-9056-cd05f510a279 Status: JobStatus.DONE\n", "2: 7b646f18-198d-40d7-a3f1-cb87cb6cc7a7 Status: JobStatus.DONE\n", "3: c62fe639-e53a-49ec-bc15-c0d7284d723a Status: JobStatus.DONE\n", "4: 56497e19-2105-484f-a6e6-23f29445030e Status: JobStatus.DONE\n", "5: d369dceb-2bf0-42ae-9fc0-eba869e388a2 Status: JobStatus.DONE\n", "6: 72fc139b-7d58-429a-806d-9030b90fd155 Status: JobStatus.DONE\n", "7: 0281d8f6-7ba7-49e8-97d7-8e0ee2b6da32 Status: JobStatus.DONE\n", "8: 259c317d-8a14-433e-a6d0-4595da57bbc8 Status: JobStatus.DONE\n", "9: 901a0c54-47bd-4caf-9130-dadb11ffc020 Status: JobStatus.DONE\n", "10: 41d70035-4510-42a1-b8a9-20128bae359f Status: JobStatus.DONE\n" ] } ], "source": [ "number_of_records = 10\n", "offset = 0\n", "counter = 1\n", "\n", "jobs = c12_simulator_backend.jobs(number_of_records, offset)\n", "\n", "for job in jobs:\n", " print(f\"{counter}: {job.job_id()} Status: {job.status()}\")\n", " counter += 1\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For each job, it is possible to get the circuit sent to the simulator for execution. But, it is even possible to get the transpiled version of this circuit to see what the circuit has been run after the transpilation process." ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Also it is possible to retrieve the circuit that has been run for specific job\n", "first_job = jobs[1]\n", "first_job_qasm = first_job.get_qasm() # Get OpenQASM string\n", "first_job_circuit = first_job.get_circuit()\n", "first_job_circuit.draw('mpl')" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Getting the transpiled circuit\n", "# NOTICE: It can be possible that due to a bug in Qiskit's transpile function some circuits are wrongly converted to QASM string\n", "\n", "first_job_transpiled_qasm = first_job.get_qasm(transpiled=True) # Get transpiled OpenQASM string\n", "first_job_transpiled_circuit = first_job.get_circuit(transpiled=True)\n", "first_job_transpiled_circuit.draw('mpl')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Query job by UUID\n", "\n", "Jobs can be searched by their UUID using the `get_job()` method." ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Job id : 7b646f18-198d-40d7-a3f1-cb87cb6cc7a7 JobStatus.DONE\n" ] } ], "source": [ "# Jobs can be queried by theirs UUID\n", "job_uuid = first_job.job_id()\n", "search_job = c12_simulator_backend.get_job(job_uuid)\n", "\n", "print(f\"Job id : {search_job.job_id()} {search_job.status()}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Running multiple jobs at once\n", "\n", "The `run()` method of the backend class can also accept the list of QuantumCircuit. This can be an essential feature as it allows a user to run multiple circuits simultaneously and get an array of job instances as a result." ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Job id: 87cf6476-5366-4b97-be21-b038525e1b56 - > JobStatus.RUNNING\n", "Job id: aa55dc98-b662-452c-b45b-15ff4145d066 - > JobStatus.RUNNING\n", "[0.49906378+1.35518698e-21j 0.00067965-2.03294274e-21j\n", " 0.00106109+1.35518905e-21j 0.49919548-2.03294066e-21j]\n", "[0.24953264+6.77595519e-22j 0.00033982-1.01647441e-21j\n", " 0.00053055+6.77596554e-22j 0.24959849-1.01647337e-21j\n", " 0.24953114+6.77591464e-22j 0.00033982-1.01646833e-21j\n", " 0.00053055+6.77592499e-22j 0.24959699-1.01646729e-21j]\n" ] } ], "source": [ "# Array where the circuits will be stored\n", "circuits_to_run = []\n", "\n", "# Creating the circuits\n", "circuit_1 = QuantumCircuit(2)\n", "circuit_1.h(0)\n", "circuit_1.cx(0, 1)\n", "\n", "circuit_2 = QuantumCircuit(3)\n", "circuit_2.h(0)\n", "circuit_2.cx(0, 1)\n", "circuit_2.x(2)\n", "circuit_2.h(2)\n", "\n", "circuits_to_run.append(circuit_1)\n", "circuits_to_run.append(circuit_2)\n", "\n", "# Running the jobs\n", "c12_jobs = c12_simulator_backend.run(circuits_to_run)\n", "\n", "# Printing the UUID of the jobs\n", "for job in c12_jobs:\n", " print(f\"Job id: {job.job_id()} - > {job.status()}\")\n", "\n", "# Waiting for the results\n", "for job in c12_jobs:\n", " result = job.result()\n", " print(result.get_statevector())" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.13" } }, "nbformat": 4, "nbformat_minor": 4 }